/**
 * XL-Payment 状态管理
 */
import { reactive } from 'vue';

// 默认状态
const defaultState = {
  // 初始化状态
  initialized: false,
  
  // 运行环境
  env: {
    platform: '',
    system: '',
    appName: '',
    isH5: false,
    isApp: false,
    isMP: false
  },
  
  // 支付统计
  stats: {
    total: 0,     // 总支付次数
    success: 0,   // 成功次数
    failed: 0,    // 失败次数
    refunded: 0   // 退款次数
  },
  
  // 最近的错误
  error: null,
  
  // 活跃订单
  activeOrders: []
};

// 创建响应式状态
const state = reactive({
  ...defaultState
});

// 事件监听器
const eventListeners = {
  orderStatusChange: [],
  paymentSuccess: [],
  paymentFailed: [],
  error: []
};

/**
 * 支付状态管理
 */
function createStore() {
  /**
   * 设置状态
   * @param {Object} newState 状态对象
   */
  function setState(newState) {
    Object.assign(state, newState);
  }
  
  /**
   * 设置环境信息
   * @param {Object} env 环境信息
   */
  function setEnv(env) {
    state.env = {
      ...state.env,
      ...env
    };
  }
  
  /**
   * 更新支付统计
   * @param {String} type 统计类型
   * @param {Number} increment 增量
   */
  function updateStats(type, increment = 1) {
    if (state.stats[type] !== undefined) {
      state.stats[type] += increment;
    }
  }
  
  /**
   * 设置错误信息
   * @param {Object} error 错误对象
   */
  function setError(error) {
    state.error = error;
    
    // 触发错误事件
    if (error) {
      triggerEvent('error', error);
    }
  }
  
  /**
   * 清除错误信息
   */
  function clearError() {
    state.error = null;
  }
  
  /**
   * 添加活跃订单
   * @param {Object} order 订单对象
   */
  function addActiveOrder(order) {
    const index = state.activeOrders.findIndex(o => o.id === order.id);
    if (index === -1) {
      state.activeOrders.push(order);
      updateStats('total');
    } else {
      state.activeOrders[index] = order;
    }
  }
  
  /**
   * 更新活跃订单
   * @param {String} orderId 订单ID
   * @param {Object} updates 更新内容
   */
  function updateActiveOrder(orderId, updates) {
    const index = state.activeOrders.findIndex(o => o.id === orderId);
    if (index !== -1) {
      state.activeOrders[index] = {
        ...state.activeOrders[index],
        ...updates
      };
      
      // 更新统计
      if (updates.status) {
        if (updates.status === 'PAID' || updates.status === 'SUCCESS') {
          updateStats('success');
        } else if (updates.status === 'FAILED' || updates.status === 'CLOSED') {
          updateStats('failed');
        } else if (updates.status === 'REFUNDED' || updates.status === 'PARTIAL_REFUNDED') {
          updateStats('refunded');
        }
      }
    }
  }
  
  /**
   * 移除活跃订单
   * @param {String} orderId 订单ID
   */
  function removeActiveOrder(orderId) {
    const index = state.activeOrders.findIndex(o => o.id === orderId);
    if (index !== -1) {
      state.activeOrders.splice(index, 1);
    }
  }
  
  /**
   * 添加事件监听器
   * @param {String} event 事件名称
   * @param {Function} callback 回调函数
   * @returns {Function} 移除监听器的函数
   */
  function addEventListener(event, callback) {
    if (!eventListeners[event]) {
      eventListeners[event] = [];
    }
    
    eventListeners[event].push(callback);
    
    // 返回移除监听器的函数
    return () => {
      const index = eventListeners[event].indexOf(callback);
      if (index !== -1) {
        eventListeners[event].splice(index, 1);
      }
    };
  }
  
  /**
   * 触发事件
   * @param {String} event 事件名称
   * @param {*} data 事件数据
   */
  function triggerEvent(event, data) {
    if (eventListeners[event]) {
      for (const callback of eventListeners[event]) {
        try {
          callback(data);
        } catch (error) {
          console.error(`事件处理器错误: ${error.message}`);
        }
      }
    }
  }
  
  /**
   * 重置状态
   */
  function resetState() {
    Object.assign(state, defaultState);
  }
  
  // 返回 store 对象
  return {
    // 状态
    state,
    
    // 方法
    setState,
    setEnv,
    updateStats,
    setError,
    clearError,
    addActiveOrder,
    updateActiveOrder,
    removeActiveOrder,
    addEventListener,
    triggerEvent,
    resetState
  };
}

// 创建并导出单例
const store = createStore();
export default store; 